package correctness;

import static org.junit.Assert.*;

import java.util.Map;

import model.LogicType;
import model.editormodel.EditorModel;
import model.editormodel.Input;
import model.editormodel.LogicEditorElement;
import model.editormodel.Output;
import model.simulationmodel.LogicValue;
import model.simulationmodel.SimulationModel;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;


/**
 * Diese Klasse testet stichprobenartig, ob die Simulation einer Schaltung
 * korrekte Ergebnisse liefert
 * 
 * @author Team Locsi
 * 
 */
public class Circuit2Test {

	private static EditorModel eModel;
	private static SimulationModel sModel;

	/**
	 * Diese Methode initialisiert die Attribute. Ausserdem wird eine Schaltung
	 * erstellt
	 */
	@BeforeClass
	public static void initialize() {
		eModel = new EditorModel();
		// Schalter hinzufuegen
		eModel.addLogicElement(LogicType.SWITCH, "switch", 1, 1); // 1
		eModel.addLogicElement(LogicType.CLOCK, "clock", 1, 20); // 2
		eModel.addLogicElement(LogicType.SWITCH, "switch", 1, 40); // 3
		eModel.addLogicElement(LogicType.SWITCH, "switch", 1, 60); // 4
		eModel.addLogicElement(LogicType.CLOCK, "clock", 1, 80); // 5

		// Bauteile hinzufuegen
		eModel.addLogicElement(LogicType.NOT, "not", 30, 1); // 6
		eModel.addLogicElement(LogicType.SELFDEFINED, "JUNIT_Bauteil", 30, 30); // 7
		eModel.addLogicElement(LogicType.OR, "or", 30, 70); // 8
		eModel.addLogicElement(LogicType.TWO_MX, "2mx", 30, 100); // 9
		eModel.addLogicElement(LogicType.NODE, "node", 50, 1); // 10
		eModel.addLogicElement(LogicType.FLIPFLOP, "flipflop", 50, 30); // 11
		eModel.addLogicElement(LogicType.NOT, "not", 50, 60); // 12
		eModel.addLogicElement(LogicType.AND, "and", 80, 1); // 13
		eModel.addLogicElement(LogicType.AND, "and", 80, 30); // 14
		eModel.addLogicElement(LogicType.NODE, "node", 80, 60); // 15
		eModel.addLogicElement(LogicType.NOT, "not", 120, 60); // 16
		eModel.addLogicElement(LogicType.NAND, "nand", 150, 60); // 17

		// Lampen hinzufuegen
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 1); // 18
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 30);// 19
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 60);// 20
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 90);// 21
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 120);// 22
		eModel.addLogicElement(LogicType.LAMP, "lamp", 180, 150);// 23

		// Leitungen hinzufuegen
		eModel.setConnection(getEditorElement().get("switch_1").getOutputs()
				.get(Output.STD_O), getEditorElement().get("not_6").getInputs()
				.get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("clock_2").getOutputs()
				.get(Output.STD_O), getEditorElement().get("JUNIT_Bauteil_7")
				.getInputs().get("SWITCH_2"));
		eModel.setConnection(getEditorElement().get("switch_3").getOutputs()
				.get(Output.STD_O), getEditorElement().get("JUNIT_Bauteil_7")
				.getInputs().get("SWITCH_3"));
		eModel.setConnection(getEditorElement().get("switch_4").getOutputs()
				.get(Output.STD_O), getEditorElement().get("or_8").getInputs()
				.get(Input.STD_B));
		eModel.setConnection(getEditorElement().get("clock_5").getOutputs()
				.get(Output.STD_O), getEditorElement().get("2mx_9").getInputs()
				.get(Input.SELECT));
		eModel.setConnection(
				getEditorElement().get("not_6").getOutputs().get(Output.STD_O),
				getEditorElement().get("node_10").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("JUNIT_Bauteil_7").getOutputs()
						.get("LAMP_5"),
				getEditorElement().get("flipflop_11").getInputs()
						.get(Input.FF_SET));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_Q), getEditorElement().get("flipflop_11")
				.getInputs().get(Input.FF_RESET));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_NQ), getEditorElement().get("or_8").getInputs()
				.get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("or_8").getOutputs().get(Output.STD_O),
				getEditorElement().get("not_12").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("not_12").getOutputs().get(Output.STD_O),
				getEditorElement().get("2mx_9").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("node_10").getOutputs()
				.get(Output.STD_O), getEditorElement().get("and_13")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("and_13").getOutputs().get(Output.STD_O),
				getEditorElement().get("and_13").getInputs().get(Input.STD_B));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_Q), getEditorElement().get("and_14").getInputs()
				.get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_NQ), getEditorElement().get("and_14")
				.getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("not_12").getOutputs().get(Output.STD_O),
				getEditorElement().get("node_15").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("node_15").getOutputs()
				.get(Output.STD_O), getEditorElement().get("not_16")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("node_15").getOutputs()
				.get(Output.STD_O), getEditorElement().get("nand_17")
				.getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("not_16").getOutputs().get(Output.STD_O),
				getEditorElement().get("2mx_9").getInputs().get(Input.STD_B));
		eModel.setConnection(
				getEditorElement().get("not_16").getOutputs().get(Output.STD_O),
				getEditorElement().get("nand_17").getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("and_13").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_18").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_Q), getEditorElement().get("lamp_19")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("flipflop_11").getOutputs()
				.get(Output.FF_NQ), getEditorElement().get("lamp_20")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("and_14").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_21").getInputs().get(Input.STD_A));
		eModel.setConnection(getEditorElement().get("nand_17").getOutputs()
				.get(Output.STD_O), getEditorElement().get("lamp_22")
				.getInputs().get(Input.STD_A));
		eModel.setConnection(
				getEditorElement().get("2mx_9").getOutputs().get(Output.STD_O),
				getEditorElement().get("lamp_23").getInputs().get(Input.STD_A));
		sModel = new SimulationModel(eModel);
		sModel.updateSimulationElements();
	}

	/**
	 * private HilfsMethode um alles Elemete des CircuitModels zu bekommen
	 * 
	 * @return Map<<code>String, LogicEditorElement></code> - alle Elemete einer
	 *         Schaltung
	 */
	private static Map<String, LogicEditorElement> getEditorElement() {
		return eModel.getCircuitModel().getUnmodifableElementsOnEditor();

	}

	/**
	 * Diese Methode wird vor jeder Test-Methode aufgerufen. Die Attribute
	 * werden auf den Ausgangszustand zurueck gesetzt
	 */
	@Before
	public void reset() {
		initialize();
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: alle Schalter und Taktgeber auf L1
	 * 
	 */
	@Test
	public void testBelegung1() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_1"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe18 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_18"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: alle Schalter und Taktgeber auf L0
	 * 
	 */
	@Test
	public void testBelegung2() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_1"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe18 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_18"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: alle Schalter und Taktgeber auf undefiniert
	 * 
	 */
	@Test
	public void testBelegung3() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_1"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe18 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_18"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L1, Schalter3: L0, Schalter4: L0, Taktgeber5: L1
	 * 
	 */
	@Test
	public void testBelegung4() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L0, Schalter3: L1, Schalter4: L1, Taktgeber5: L0
	 * 
	 */
	@Test
	public void testBelegung5() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L1, Schalter3: L1, Schalter4: undefiniert,
	 * Taktgeber5: L1
	 * 
	 */
	@Test
	public void testBelegung6() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L0, Schalter3: L0, Schalter4: L0, Taktgeber5: L1
	 * 
	 */
	@Test
	public void testBelegung7() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L1, Schalter3: L1, Schalter4: L0, Taktgeber5:
	 * undefiniert
	 * 
	 */
	@Test
	public void testBelegung8() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: L0, Schalter3: undefiniert, Schalter4: L0,
	 * Taktgeber5: L1
	 * 
	 */
	@Test
	public void testBelegung9() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L0);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L1);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
	}

	/**
	 * Testet das Ergebines der Simulation mit folgender Belegung der Schalter
	 * und Taktgeber: Schalter1 wird nicht mehr gesetzt -> alle Fälle bereits
	 * abgetestet, Taktgeber2: undefiniert, Schalter3: L1, Schalter4: L1,
	 * Taktgeber5: L0
	 * 
	 */
	@Test
	public void testBelegung10() {

		// Schalter und Taktgeber setzten!
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2"))
				.setInputValue(Input.STD_A, LogicValue.UNDEFINED);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.setInputValue(Input.STD_A, LogicValue.L1);
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5"))
				.setInputValue(Input.STD_A, LogicValue.L0);

		// Schaltung Simulieren
		calcSwitches();

		// Belegungen der Lampen testen
		assertTrue(
				"Belegung des Lampe19 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_19"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe20 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_20"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe21 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_21"))
						.getLogicValue(Output.STD_O) == LogicValue.UNDEFINED);
		assertTrue(
				"Belegung des Lampe22 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_22"))
						.getLogicValue(Output.STD_O) == LogicValue.L1);
		assertTrue(
				"Belegung des Lampe23 ist falsch",
				sModel.getSimulationElements()
						.get(sModel.getLogicElements().get("lamp_23"))
						.getLogicValue(Output.STD_O) == LogicValue.L0);
	}

	/**
	 * private HilfsMethode zur Berechnung der Schalter
	 */
	private void calcSwitches() {

		// Schalter berechnen
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_1"))
				.calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_2")).calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_3"))
				.calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("switch_4"))
				.calcLogicValue();
		sModel.getSimulationElements()
				.get(sModel.getLogicElements().get("clock_5")).calcLogicValue();
		sModel.calcElementsToCalc();
	}
}
